#ifndef __GAME_TEMPLATE_H__
#define __GAME_TEMPLATE_H__

#include "game_macros.h"
///**
//*@brief 类型转换类型
//*/
template <class A, class B>
class CTypeConvert_t
{
private:
  union
  {
    A a;
    B b;
  } _data;

public:
  CTypeConvert_t(B _b)
  {
    _data.b = _b;
  }
  inline operator A() const
  {
    return _data.a;
  }
};

/**
 *@brief 类型转换
 */
template <class A, class B>
inline A CTypeConvert(B _b)
{
  return CTypeConvert_t<A, B>(_b);
}

/**
 *@brief 成员函数类型
 */
template <class _Ty, class _Result, class _Arg1 = void, class _Arg2 = void, class _Arg3 = void, class _Arg4 = void, class _Arg5 = void, class _Arg6 = void, class _Arg7 = void, class _Arg8 = void>
class CMemFun_t
{
private:
  _Ty *_self;
  typedef _Result (_Ty::*func_t)(_Arg1, _Arg2, _Arg3, _Arg4, _Arg5, _Arg6, _Arg7, _Arg8);
  func_t func;

public:
  CMemFun_t() : _self(nullptr), func(nullptr)
  {
  }

  CMemFun_t(_Ty *_ty, func_t _func) : _self(_ty), func(_func)
  {
  }

  template <class T, class _A1, class _A2, class _A3, class _A4, class _A5, class _A6, class _A7, class _A8>
  CMemFun_t(T *_ty, _Result (T::*_func)(_A1, _A2, _A3, _A4, _A5, _A6, _A7, _A8)) : _self(CTypeConvert<_Ty *>(_ty)), func(CTypeConvert<func_t>(_func))
  {
    CC_ASSERT(sizeof(_Arg1) == sizeof(_A1),"CMemFun_t", "CMemFun_t args error.");
    CC_ASSERT(sizeof(_Arg2) == sizeof(_A2),"CMemFun_t", "CMemFun_t args error.");
    CC_ASSERT(sizeof(_Arg3) == sizeof(_A3),"CMemFun_t", "CMemFun_t args error.");
    CC_ASSERT(sizeof(_Arg4) == sizeof(_A4),"CMemFun_t", "CMemFun_t args error.");
    CC_ASSERT(sizeof(_Arg5) == sizeof(_A5),"CMemFun_t", "CMemFun_t args error.");
    CC_ASSERT(sizeof(_Arg6) == sizeof(_A6),"CMemFun_t", "CMemFun_t args error.");
    CC_ASSERT(sizeof(_Arg7) == sizeof(_A7),"CMemFun_t", "CMemFun_t args error.");
    CC_ASSERT(sizeof(_Arg8) == sizeof(_A8),"CMemFun_t", "CMemFun_t args error.");
  }

  inline _Result operator()(_Arg1 _arg1, _Arg2 _arg2, _Arg3 _arg3, _Arg4 _arg4, _Arg5 _arg5, _Arg6 _arg6, _Arg7 _arg7, _Arg8 _arg8)
  {
    return (_self->*func)(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6, _arg7, _arg8);
  }

  bool operator==(const CMemFun_t &v)
  {
    return (_self == v._self && func == v.func);
  }

  operator bool() const
  {
    return (_self && func);
  }
};

/**
 *@brief 成员函数类型
 */
template <class _Ty, class _Result, class _Arg1, class _Arg2, class _Arg3>
class CMemFun_t<_Ty, _Result, _Arg1, _Arg2, _Arg3>
{
private:
  _Ty *_self;
  typedef _Result (_Ty::*func_t)(_Arg1, _Arg2, _Arg3);
  func_t func;

public:
  CMemFun_t() : _self(nullptr), func(nullptr)
  {
  }

  CMemFun_t(_Ty *_ty, func_t _func) : _self(_ty), func(_func)
  {
  }

  template <class T, class _A1, class _A2, class _A3>
  CMemFun_t(T *_ty, _Result (T::*_func)(_A1, _A2, _A3)) : _self(CTypeConvert<_Ty *>(_ty)), func(CTypeConvert<func_t>(_func))
  {
    CC_ASSERT(sizeof(_Arg1) == sizeof(_A1),"CMemFun_t", "CMemFun_t args error.");
    CC_ASSERT(sizeof(_Arg2) == sizeof(_A2),"CMemFun_t", "CMemFun_t args error.");
    CC_ASSERT(sizeof(_Arg3) == sizeof(_A3),"CMemFun_t", "CMemFun_t args error.");
  }

  inline _Result operator()(_Arg1 _arg1, _Arg2 _arg2, _Arg3 _arg3)
  {
    return (_self->*func)(_arg1, _arg2, _arg3);
  }

  bool operator==(const CMemFun_t &v)
  {
    return (_self == v._self && func == v.func);
  }

  operator bool() const
  {
    return (_self && func);
  }
};

/**
 *@brief 成员函数类型
 */
template <class _Ty, class _Result, class _Arg1, class _Arg2>
class CMemFun_t<_Ty, _Result, _Arg1, _Arg2>
{
private:
  _Ty *_self;
  typedef _Result (_Ty::*func_t)(_Arg1, _Arg2);
  func_t func;

public:
  CMemFun_t() : _self(nullptr), func(nullptr)
  {
  }

  CMemFun_t(_Ty *_ty, func_t _func) : _self(_ty), func(_func)
  {
  }

  template <class T, class _A1, class _A2>
  CMemFun_t(T *_ty, _Result (T::*_func)(_A1, _A2)) : _self(CTypeConvert<_Ty *>(_ty)), func(CTypeConvert<func_t>(_func))
  {
    CC_ASSERT(sizeof(_Arg1) == sizeof(_A1),"CMemFun_t", "CMemFun_t args error.");
    CC_ASSERT(sizeof(_Arg2) == sizeof(_A2),"CMemFun_t", "CMemFun_t args error.");
  }

  inline _Result operator()(_Arg1 _arg1, _Arg2 _arg2)
  {
    return (_self->*func)(_arg1, _arg2);
  }

  bool operator==(const CMemFun_t &v)
  {
    return (_self == v._self && func == v.func);
  }

  operator bool() const
  {
    return (_self && func);
  }
};

/**
 *@brief 成员函数类型
 */
template <class _Ty, class _Result, class _Arg1>
class CMemFun_t<_Ty, _Result, _Arg1>
{
private:
  _Ty *_self;
  typedef _Result (_Ty::*func_t)(_Arg1);
  func_t func;

public:
  CMemFun_t() : _self(nullptr), func(nullptr)
  {
  }

  CMemFun_t(_Ty *_ty, func_t _func) : _self(_ty), func(_func)
  {
  }

  template <class T, class _A1>
  CMemFun_t(T *_ty, _Result (T::*_func)(_A1)) : _self(CTypeConvert<_Ty *>(_ty)), func(CTypeConvert<func_t>(_func))
  {
    C_ASSERT(sizeof(_Arg1) == sizeof(_A1), "CMemFun_t args error.");
  }

  inline _Result operator()(_Arg1 _arg1)
  {
    return (_self->*func)(_arg1);
  }

  bool operator==(const CMemFun_t &v)
  {
    return (_self == v._self && func == v.func);
  }

  operator bool() const
  {
    return (_self && func);
  }
};

/**
 *@brief 成员函数类型
 */
template <class _Ty, class _Result>
class CMemFun_t<_Ty, _Result>
{
private:
  _Ty *_self;
  typedef _Result (_Ty::*func_t)();
  func_t func;

public:
  CMemFun_t() : _self(nullptr), func(nullptr)
  {
  }

  CMemFun_t(_Ty *_ty, func_t _func) : _self(_ty), func(_func)
  {
  }

  template <class T>
  CMemFun_t(T *_ty, _Result (T::*_func)()) : _self(CTypeConvert<_Ty *>(_ty)), func(CTypeConvert<func_t>(_func))
  {
  }

  inline _Result operator()()
  {
    return (_self->*func)();
  }

  bool operator==(const CMemFun_t &v)
  {
    return (_self == v._self && func == v.func);
  }

  operator bool() const
  {
    return (_self && func);
  }
};

#endif
